package cloud.xiangyixiang.www.spring.boot.java.basics.controller;

import cloud.xiangyixiang.www.spring.boot.java.basics.pojo.bo.UserBo;

import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * JAVA 集合
 * </p>
 *
 * @author 知行录
 * @date 2023/10/7 10:54
 */
public class CollectionController {

    public static void main(String[] args) {

        description();

        test1();

        test2();

        test3();

        test4();
        test5();
        test6();
        test7();
        test8();
        test9();
        test10();

        test11();
        test12();
    }

    public static void description(){
        System.out.println("Set子接口:无序，不允许重复，检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。");
        System.out.println("List子接口:有序，可以有重复元素，和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。");
        System.out.println("Set和List具体子类：");
        System.out.println("  Set");
        System.out.println("   |————HashSet：以哈希表的形式存放元素，插入删除速度很快。");
        System.out.println("  List");
        System.out.println("   |————ArrayList：动态数组");
        System.out.println("   |————LinkedList：链表、队列、堆栈。");

        System.out.println();
    }

    /**
     * Set
     */
    public static void test1(){
        // HashSet：使用hashmap的一个集的实现。虽然集定义成无序，但必须存在某种方法能高效地找到一个对象。使用一个hashmap对象实现集的存储和检索操作时在固定时间内实现的。
        Set set = new HashSet();
        set.add("Bernadine");
        set.add("Elizabeth");
        set.add("Gene");
        set.add("Elizabeth");
        set.add("Clara");
        System.out.println(set);

        //  TreeSet：在集中以升序对对象排序的集的实现。这意味着从一个TreeSet对象获得第一个迭代器将按升序提供对象。TreeSet类使用了一个TreeMap。
        Set sortedSet = new TreeSet(set);
        System.out.println(sortedSet);

        // 为优化hashset空间的使用，可以调优初始容量和负载因子。TreeSet 不包含调优选项，因为树总是平衡的，保证了插入、删除、查询的性能的高效。
        // 当您要从集合中以有序的方式抽取元素时，TreeSet实现会有用处。为了能顺利进行，添加到TreeSet的元素必须是可排序的。
        System.out.println();
    }

    /**
     * List
     */
    public static void test2(){
        // List接口继承了Collection接口，定义一个允许重复项的有序集合。该接口不但能够对列表的一部分进行处理，还添加了面向位置的操作

        // 实际上有两种list：一种是基本的ArrayList，其优点在于随机访问元素，
        // 另一种是更强大的LinkedList，它并不是快速随机访问设计的，而是具有更通用的方法。
        List<String> linkedList = new LinkedList<>();
        for (int i = 0; i <= 5; i++) {
            linkedList.add("a" + i);
        }
        System.out.println(linkedList);

        linkedList.add(3,"a100");
        System.out.println(linkedList);

        linkedList.set(6,"a200");
        System.out.println(linkedList);

        System.out.println(linkedList.get(2));

        System.out.println(linkedList.indexOf("a3"));

        linkedList.remove(1);
        System.out.println(linkedList);

        System.out.println();
    }

    /**
     * MAP 操作
     */
    public static void test3(){
        String[] array = {"a","b","c","d","e"};
        Map<String, Integer> map = new HashMap<>();
        for (int i=0, n=array.length; i<n; i++) {
            String key = array[i];
            int frequency = i+1;
            map.put(key, frequency);
        }
        System.out.println(map);

        // treeMap
        Map<String, Integer> sortedMap = new TreeMap<>(map);
        System.out.println(sortedMap);

        // hashmap的同步
        Map<String, Integer> map1 = Collections.synchronizedMap(map);
        System.out.println(map1);

        System.out.println();
    }

    /**
     * List 循环删除问题
     */
    public static void test4(){
        System.out.println("List 循环删除问题， for i 方式：");
        ArrayList<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("33");
        list.add("44");
        list.add("55");
        System.out.println(list);
        for (int i = 0; i < list.size(); i++) {
            if (i == 1 || i == 2){
                list.remove(i);
            }
        }
        System.out.println(list);

        System.out.println();
    }

    /**
     * List 循环删除问题
     *  foreach equals 判断删除
     */
    public static void test5(){
        System.out.println("List 循环删除问题， 高级for方式：");
        ArrayList<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("33");
        list.add("44");
        list.add("55");
        System.out.println(list);
        for (String str: list) {
            if ("22".equals(str) || "33".equals(str)){
                list.remove(str);
            }
        }
        System.out.println(list);

        System.out.println();
    }

    /**
     * List 循环删除问题
     *  lambda removeIf equals 判断删除
     */
    public static void test6(){
        System.out.println("List 循环删除问题， removeIf 方式：");
        ArrayList<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("33");
        list.add("44");
        list.add("55");
        System.out.println(list);
        list.removeIf(str -> "22".equals(str) || "33".equals(str));
        System.out.println("removeIf便利删除：" + list);

        System.out.println();
    }

    /**
     * List 循环删除问题
     *  stream filter equals 判断删除
     */
    public static void test7(){
        System.out.println("List 循环删除问题， stream 方式：");
        ArrayList<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("33");
        list.add("44");
        list.add("55");
        System.out.println(list);

        List<String> reList = list.stream().filter(str -> !"22".equals(str) && !"33".equals(str)).collect(Collectors.toList());
        System.out.println("stream遍历remove：" + reList);

        System.out.println();
    }

    public static void test8(){
        System.out.println("List 循环删除问题， 复制方式实现：");
        ArrayList<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("33");
        list.add("44");
        list.add("55");
        System.out.println(list);

        ArrayList<String> reList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (i == 1 || i == 2){
            } else {
                reList.add(list.get(i));
            }
        }
        System.out.println("复制方式实现：" + reList);

        System.out.println();
    }

    public static void test9(){
        System.out.println("List 循环删除问题， Iterator遍历方式：");
        ArrayList<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("33");
        list.add("44");
        list.add("55");
        System.out.println(list);

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            if ("22".equals(str) || "33".equals(str)){
                iterator.remove();
            }
        }
        System.out.println("Iterator遍历remove：" + list);

        System.out.println();
    }

    public static void test10(){
        System.out.println("List 循环删除问题， 普通for循环倒序方式：");
        ArrayList<String> list = new ArrayList<>();
        list.add("11");
        list.add("22");
        list.add("33");
        list.add("44");
        list.add("55");
        System.out.println(list);

        int listSize = list.size();
        for (int i = listSize -1; i >= 0; i--) {
            String str = list.get(i);
            if ("22".equals(str) || "33".equals(str)){
                list.remove(i);
            }
        }
        System.out.println("普通for循环遍历倒序remove：" + list);

        System.out.println();
    }

    public static <T> void test11(){
        List<T> list = new ArrayList<>();
        UserBo user = new UserBo();
        user.setUsername("ZhangSan");
        user.setAge(1);
        list.add((T) user);
    }

    public static void test12(){
        List<?> list = new ArrayList<>();
        UserBo user = new UserBo();
        user.setUsername("ZhangSan");
        user.setAge(1);
        list.add(user);
    }




}
